
package cn.com.header.core.util;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;



/**
 * 数据查找分页对象
 * @author LinZongxue 2012-12-4(修改)
 */
public class Page implements Serializable{
	//@Resource private RoleService roleSvc;
	//-- 分页查询参数 --//
	private static final long serialVersionUID = 1L;  
	private int limit = 15;
	private int start = 0;
	public int pageNo = 1;
	//移动端页码数
	/*private int pageNum = 1;*/
	private String orderCol = null;
	private String orderDir = null;


	private int startpage;
	private int endpage;
	/**
	 * 总页数
	 */
	public int totalPages;

	public int getStartpage() {
		if(pageNo<=2)//请求页面小于等于2
		{
			startpage=1;
		}
		else
		{
			startpage=pageNo-2;

		}
		return startpage;
	}

	public int getEndpage() {
		if(pageNo<=2)//请求页面小于等于2
		{
			endpage=5;
			if(endpage>getLastPageNum())
			{
				endpage=getLastPageNum();
			}
		}
		else
		{
			startpage=pageNo-2;
			endpage=pageNo+2;
			if(endpage>=getLastPageNum())
			{
				endpage=getLastPageNum();
			}
		}
		return endpage;
	}
	/** 
	 * 存放查询条件。<br/>
	 * 【注意】查询条件的属性名称不能随意起名，要避免与HashMap内部的属性名相同，否则在mybatis中容易出现错误。
	 * 已发现以下名称不可取：<br/>
	 * · keys
	 */
	private Map<String, Object> conds = new CondMap<String, Object>();
	
	private boolean export = false;

	//-- 返回结果 --//
	private List<?> result = new ArrayList<Object>();
	private long total = -1;

	public Page(int pageNo) {
		this.pageNo = pageNo;
		this.start=(pageNo-1)*limit;
	}
	public Page(int pageNo, int limit) {
		this.pageNo = pageNo;
		this.limit = limit;
		this.start=(pageNo-1)*limit;
	}

	public int getPageNo() {
		return pageNo;
	}

	public void setPageNo(int pageNo) {
		this.pageNo = pageNo;
	}

	/**
	 * 根据pageSize与totalCount计算总页数, 默认值为-1.
	 */
	public int getTotalPages() {
		return (int) (total / limit + (total % limit == 0 ? 0 : 1));
	}

	public void setTotalPages(int totalPages) {
		this.totalPages = totalPages;
	}

/*
	public int getPageNum() {
		return pageNum;
	}

	public void setPageNum(int pageNum) {
		this.pageNum = pageNum;
	}
*/


	public int getLimit() {
		return limit;
	}

	public void setLimit(int limit) {
		this.limit = limit;
	}

	public int getStart() {
		return start;
	}

	public void setStart(int start) {
		this.start = start;
	}
	/**
	 * 设置移端最后页码
	 * @return
	 */
	public int getLastPageNum(){
		return (int) (total / limit + (total % limit == 0 ? 0 : 1));
	}

	/**
	 * 是否已设置排序字段,无默认值.
	 */

	public boolean isOrderBySetted() {
		return (LangUtils.isNotEmpty(orderCol) && LangUtils.isNotEmpty(orderDir));
	}

	/**
	 * 获得页内的记录列表.
	 */
	public List<?> getResult() {
		return result;
	}

	/**
	 * 设置页内的记录列表.
	 */
	public void setResult(final List<?> result) {
		this.result = result;
	}

	/**
	 * 获得总记录数, 默认值为-1.
	 */
	public long getTotal() {
		return total;
	}

	/**
	 * 设置总记录数.
	 */
	public void setTotal(final long total) {
		this.total = total;
	}

	public String getOrderCol() {
		return orderCol;
	}

	/**
	 * 设置排序的列，同时，将大写字母换成下划线加小写字母，以适应数据库字段的命名风格
	 */
	public void setOrderCol(String orderCol) {
		this.orderCol = LangUtils.toUnlineName(orderCol);
	}

	public String getOrderDir() {
		return orderDir;
	}

	public void setOrderDir(String orderDir) {
		if (orderDir != null){
			orderDir = orderDir.trim().toLowerCase();
			if (!orderDir.equals("asc") && !orderDir.equals("desc")) orderDir = "asc";
		}
		this.orderDir = orderDir;
	}

	public Map<String, Object> getConds() {
		return conds;
	}

	public void setConds(Map<String, Object> conds) {
		this.conds = conds;
	}

	public boolean isExport() {
		return export;
	}

	/**
	 * 设置为数据导出，将不分页查询
	 */
	public void setExport(boolean export) {
		this.export = export;
		if (export){
			this.limit = 0; //不分页
		}
	}
	
	/**
	 * 将查询条件中指定的字段添加%，以便完成like模糊查询
	 * @param fields 要模糊查询的字段名称，多个名称用逗号分隔
	 */
	public Page makeSqlLike(String fields){
		if (fields == null) return this;
		for (String field : fields.split(",")){
			Object value = conds.get(field.trim());
			if (LangUtils.isEmpty(value)){
				conds.put(field, null);
			}
			else{
				conds.put(field, LangUtils.makeSqlLike(value.toString()));
			}
		}
		return this;
	}
	
	/**
	 * 对指定的查询条件，如果查询关键词中有空格，则改用数组来存储，并为每个元素前后添加%，以便mybatis使用。
	 * 当同时对多个字段进行统一的模糊查询时使用此方法。
	 * @param fields 字段名，多个字段用逗号分隔
	 * @return
	 */
	public Page makeMultiSqlLike(String fields){
		if (fields == null) return this;
		for (String field : fields.split(",")){
			Object value = conds.get(field.trim());
			if (value == null) continue;
			conds.put(field, LangUtils.makeMultiSqlLike(validNameLike(value.toString())));
		}
		return this;
	}
	
	/**
	 * 模糊查询的"%"和"_"问题
	 * 在有"%"和"_"的地方前面加上"/"
	 * @return
	 */
	public String validNameLike(String name){
		if(name.contains("%") || name.contains("_")){
			char[] arrChar = name.toCharArray();
			StringBuffer sb = new StringBuffer();
			for(int i=0; i<arrChar.length; i++){
				if("%".equals(String.valueOf(arrChar[i])) || "_".equals(String.valueOf(arrChar[i]))){
					sb.append("/").append(arrChar[i]);
				}
				sb.append(arrChar[i]);
			}
			return sb.toString();
		}
		return name;
	}


	
	public void addCond(String key, Object value){
		this.conds.put(key, value);
	}
	
	public Object getCond(String key){
		return this.conds.get(key);
	}

	public void removeCond(String key){
		this.conds.remove(key);
	}
	

	
	public boolean findCond(Page page, String key){
		if(page.getConds().containsKey(key)){
			if(page.getCond(key) != null){
				return false;
			}else{
				return true;
			}
		}
		return true;
	}
	
	/**
	 * 存放查询条件的Map类，做一些定制的特殊处理：
	 * <ul>
	 * <li>将空字符串修改为null，方便mybatis使用
	 * </ul>
	 * @author LinZongxue 2012-12-13
	 */
	@SuppressWarnings("serial")
	private class CondMap<K, V> extends HashMap<K, V>{
		public V put(K key, V value){
			if (value != null && value instanceof String && value.toString().trim().length() == 0){
				value = null;
			}
			return super.put(key, value);
		}
	}


}
